package cn.itcast.service.impl;


import cn.itcast.dao.RoleDao;
import cn.itcast.entity.PageResult;
import cn.itcast.entity.QueryPageBean;
import cn.itcast.pojo.Role;
import cn.itcast.service.RoleService;
import com.alibaba.dubbo.config.annotation.Service;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;


import java.util.List;
import java.util.stream.Stream;

@Service
public class RoleServiceImpl implements RoleService {

    @Autowired
    private RoleDao roleDao;


    /**
     * 保存用户基本信息
     *
     * @param role
     *//*
    @Override
    public void add(Role role,Integer[] permissionIds,Integer[] menuIds) {
        roleDao.add(role);
        //关联保存角色信息
        if (permissionIds != null) {
            Integer roleId = role.getId();
            setRoleAndPermission(roleId, permissionIds);
        }
        if (menuIds != null) {
            Integer roleId = role.getId();
            setRoleAndMenu(roleId, menuIds);
        }
    }
    *//**
     * 设置角色和菜单的关联信息
     *
     * @param roleId
     * @param menuIds
     *//*
    private void setRoleAndMenu(Integer roleId, Integer[] menuIds) {
        Stream.of(menuIds).forEach(menuId -> roleDao.setMenuAssociation(roleId, menuId));
    }

    *//**
     * 设置角色和权限的关联信息
     *
     * @param roleId
     * @param permissionIds
     *//*
    private void setRoleAndPermission(Integer roleId, Integer[] permissionIds) {
        Stream.of(permissionIds).forEach(permissionId -> roleDao.setPermissionAssociation(roleId, permissionId));
    }

    *//**
     * 条件查询用户信息
     *
     * @param queryString
     * @return
     *//*
    @Transactional
    @Override
    public PageResult pageQuery(Integer currentPage, Integer pageSize, String queryString) {
        PageHelper.startPage(currentPage, pageSize);
        Page<Role> page = roleDao.selectByCondition(queryString);
        return new PageResult(page.getTotal(), page.getResult());
    }

    *//**
     * 根据角色id查询角色信息
     *
     * @param id
     * @return
     *//*
    @Override
    public Role findById(Integer id) {
        return roleDao.findById(id);
    }


    *//**
     * 根据Id更新用户基本信息
     *
     * @param role
     *//*
    @Transactional
    @Override
    public void update(Role role, Integer[] permissionIds, Integer[] menuIds) {
        //更新用户基本信息
        roleDao.update(role);
        //删除用户关联权限信息
        roleDao.deletePermissionAssociation(role.getId());
        //删除用户关联菜单信息
        roleDao.deleteMenuAssociation(role.getId());
        //设置用户关联权限信息
        setRoleAndPermission(role.getId(), permissionIds);
        //设置用户关联菜单信息
        setRoleAndMenu(role.getId(),menuIds);
    }

    *//**
     * 根据id删除角色信息
     *
     * @param id
     *//*
    @Transactional
    @Override
    public void deleteById(Integer id) {

        //判断该检查项是否被引用
        int count = roleDao.selectRoleReferencedCount(id);
        if(count>0){
            throw new RuntimeException("当前角色被引用，不能删除 !");
        }

        //删除用户关联权限信息
        roleDao.deletePermissionAssociation(id);
        //删除用户关联菜单信息
        roleDao.deleteMenuAssociation(id);

        //删除用户基本信息
        roleDao.deleteById(id);
    }

    *//**
     * 查询所有用户数据
     *
     * @return
     *//*
    @Override
    public List<Role> findAll() {
        return roleDao.findAll();
    }

    *//**
     * 查询角色下的菜单ID集合
     *
     * @param roleId
     * @return
     *//*
    @Override
    public Integer[] selectedMenusId(Integer roleId) {
        return roleDao.findMenuAssociationIds(roleId);
    }

    */

    /**
     * 查询角色下的权限ID集合
     *
     * @param roleId
     * @return
     *//*
    @Override
    public Integer[] selectedPermissionsId(Integer roleId) {
        return roleDao.findPermissionAssociationIds(roleId);
    }

    @Override
    public String findKeywordById(Integer id) {
        return roleDao.findKeywordById(id);
    }
*/


    //查询所有角色信息
    public PageResult findPage(QueryPageBean queryPageBean) {
        //开启分页查询
        PageHelper.startPage(queryPageBean.getCurrentPage(), queryPageBean.getPageSize());
        //根据条件分页查询检查项信息
        Page<Role> page = roleDao.selectByCondition(queryPageBean.getQueryString());
        //构建分页数据返回
        return new PageResult(page.getTotal(), page.getResult());
    }

    //新增角色
    public void add(Integer[] permissionIds, Integer[] menuIds, Role role) {
        //调用dao新增角色
        roleDao.add(role);
        //判断菜单信息和权限信息是否为空，不为空调用dao保存
        Integer roleId = role.getId();
        if (permissionIds != null || permissionIds.length != 0) {
            //添加角色——权限列表信息
            Stream.of(permissionIds).forEach(permissionId -> roleDao.setPermissionId(roleId, permissionId));
        }
        if (menuIds != null || menuIds.length != 0) {
            //添加角色——菜单列表信息
            Stream.of(menuIds).forEach(menuId -> roleDao.setMenuId(roleId, menuId));
        }
    }

    /**
     * 查询角色列表keyword
     *
     * @param id
     * @return
     */
    @Override
    public String findKeywordById(Integer id) {
        return roleDao.findKeywordById(id);
    }


    //删除角色
    public void deleteById(Integer id) {
        //调用权限dao删除角色-权限关联关系
        roleDao.deleteRolePermission(id);
        //调用菜单dao删除角色-菜单关联关系
        roleDao.deleteRoleMenu(id);
        //调用dao删除角色基本信息
        roleDao.deleteById(id);
    }

    //根据角色id查询角色
    public Role findByRoleId(Integer id) {
        Role role = roleDao.findByRoleId(id);
        return role;
    }

    //根据角色id查询菜单id
    public Integer[] findMenuIdsByRoleId(Integer id) {
        //查询角色对应菜单个数
        return roleDao.findMenuIdsByRoleId(id);
    }

    //根据角色id查询权限id
    public Integer[] findPermissionIdsByRoleId(Integer id) {
        return roleDao.findPermissionIdsByRoleId(id);
    }


    //修改角色信息
    public void update(Integer[] permissionIds, Integer[] menuIds, Role role) {
        //获取当前角色id
        Integer roleId = role.getId();
        //先查看原本 角色-权限 信息是否存在
        Integer[] permissionIdsByRoleId = roleDao.findPermissionIdsByRoleId(roleId);
        if (permissionIdsByRoleId != null && permissionIdsByRoleId.length != 0) {
            // 存在-删除原本的 角色-权限 信息
            roleDao.deleteRolePermission(roleId);
            //删除后，添加新权限--判断修改后的 角色-权限 是否为空
            if (permissionIds != null && permissionIds.length != 0) {
                for (Integer permissionId : permissionIds) {
                    //不为空： 添加新的 角色-权限 信息
                    roleDao.setPermissionId(roleId, permissionId);
                }
            }
        } else {
            //原本权限不存在 ：判断修改后的 角色-权限 是否为空
            if (permissionIds != null && permissionIds.length != 0) {
                for (Integer permissionId : permissionIds) {
                    //不为空： 添加新的 角色-权限 信息
                    roleDao.setPermissionId(roleId, permissionId);
                }
            }
        }
        //先查看原本 角色-菜单 信息是否存在
        Integer[] menuIdsByRoleId = roleDao.findMenuIdsByRoleId(roleId);
        if (menuIdsByRoleId != null && menuIdsByRoleId.length != 0) {
            // 存在-删除原本的 角色-菜单 信息
            roleDao.deleteRoleMenu(roleId);
            //添加新的角色- 菜单 信息 - 判断修改后的角色-菜单是否为空
            if (menuIds != null && menuIds.length != 0) {
                //不为空：添加新的 角色-菜单 信息
                for (Integer menuId : menuIds) {
                    roleDao.setMenuId(roleId, menuId);
                }
            }
        } else {
            //角色-菜单信息不存在-判断修改后的角色-菜单是否为空
            if (menuIds != null && menuIds.length != 0) {
                //不为空：添加新的 角色-菜单 信息
                for (Integer menuId : menuIds) {
                    roleDao.setMenuId(roleId, menuId);
                }
            }

        }
        roleDao.update(role);
    }


    //用户查询角色
    @Override
    public List<Role> findAll() {
        return roleDao.findAll();
    }
}
